/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Xadrez.Modelo;

/**
 *
 * @author Leonardo
 */
public class TesteIA {

    public int ox;
    public int oy;
    public int dx;
    public int dy;
    private ConjuntoXY[] memoria;
    private int capacidadeDaMemoria = 10;
    private int jogadasNaMemoria = 0;
    private boolean sicilianDefense;

    public TesteIA() {
        ox = 0;
        oy = 0;
        dx = 0;
        dy = 0;

        memoria = new ConjuntoXY[capacidadeDaMemoria];
        jogadasNaMemoria = 0;

        sicilianDefense = true;

    }

    private Piece sorteiaPeca(Match m) {

        int indicePeca = ((int) (15 * Math.random())) % 15;

        Piece peca = escolhePeca(indicePeca, m);
        return peca;

    }

    private Piece escolhePeca(int n, Match m) {

        Piece peca = m.getPlayer2().getPiece()[n];

        for (int i = 0; i <= 7; i++) {
            for (int j = 0; j <= 7; j++) {

                if (m.selectSquare(i, j).getPiece() == peca) {
                    ox = i;
                    oy = j;

                    break;

                }
            }
        }
        return peca;

    }

    public void registrarJogada(int ox, int oy, int dx, int dy) {

        for (int i = 0; i < capacidadeDaMemoria - 1; i++) {
            memoria[capacidadeDaMemoria - 1 - i] = memoria[capacidadeDaMemoria - 2 - i];
        }

        memoria[0] = new ConjuntoXY();
        memoria[0].adicionarConjunto(ox, oy, dx, dy);

    }

    private class ConjuntoXY {

        private int cox;
        private int coy;
        private int cdx;
        private int cdy;
        private int valor;

        public ConjuntoXY() {
            cox = 0;
            coy = 0;
            cdx = 0;
            cdy = 0;
            valor = 0;

        }

        public void adicionarConjunto(int a, int b, int c, int d) {
            cox = a;
            coy = b;
            cdx = c;
            cdy = d;

        }

        public int getValor() {
            return this.valor;

        }

        public void setValor(int v) {
            this.valor = v;
        }

        public int getDx() {
            return this.cdx;
        }

        public int getDy() {
            return this.cdy;
        }

        public int getOx() {
            return this.cox;
        }

        public int getOy() {
            return this.coy;
        }
    }

    public void randomMove(Match m) {

        boolean randomOk = false;


        Piece peca = sorteiaPeca(m);


        int tentativasDeCadaPeca = 0;

        while (!randomOk) {

            if (tentativasDeCadaPeca <= 10) {

                peca = sorteiaPeca(m);
                tentativasDeCadaPeca = 0;
            }
            tentativasDeCadaPeca++;

            do {
                if (peca instanceof Pawn) {
                    dx = ((int) (9 * Math.random())) % 3;
                    switch (dx) {
                        case 0:
                            dx = ox - 1;
                            break;
                        case 1:
                            dx = ox;
                            break;
                        case 2:
                            dx = ox + 1;
                            break;
                    }
                    dy = ((int) (10 * Math.random())) % 2;
                    switch (dy) {
                        case 0:
                            dy = oy + 1;
                            break;
                        case 1:
                            dy = oy + 2;
                            break;
                    }

                } else if (peca instanceof Rook) {
                    dx = ((int) (8 * Math.random())) % 2;
                    switch (dx) {
                        case 0:
                            dx = ox;
                            dy = ((int) (49 * Math.random())) % 7;
                            break;
                        case 1:
                            dy = oy;
                            dx = ((int) (49 * Math.random())) % 7;
                            break;
                    }

                } else if (peca instanceof Bishop) {
                    dx = ((int) (49 * Math.random())) % 7;
                    dy = ((int) (8 * Math.random())) % 2;
                    switch (dy) {
                        case 0:
                            dy = Math.abs(dx - ox);
                            break;
                        case 1:
                            dy = -Math.abs(dx - ox);
                            break;
                    }

                } else if (peca instanceof Knight) {
                    dx = ((int) (64 * Math.random())) % 8;
                    switch (dx) {
                        case 0:
                            dx = ox + 1;
                            dy = oy + 2;
                            break;
                        case 1:
                            dx = ox + 2;
                            dy = oy + 1;
                            break;
                        case 2:
                            dx = ox - 1;
                            dy = oy - 2;
                            break;
                        case 3:
                            dx = ox - 2;
                            dy = oy - 1;
                            break;
                        case 4:
                            dx = ox - 1;
                            dy = oy + 2;
                            break;
                        case 5:
                            dx = ox - 2;
                            dy = oy + 1;
                            break;
                        case 6:
                            dx = ox + 1;
                            dy = oy - 2;
                            break;
                        case 7:
                            dx = ox + 2;
                            dy = oy - 1;
                            break;

                    }

                } else if (peca instanceof King) {
                    dx = ((int) (64 * Math.random())) % 8;
                    switch (dx) {
                        case 0:
                            dx = ox + 1;
                            dy = oy;
                            break;
                        case 1:
                            dx = ox + 1;
                            dy = oy + 1;
                            break;
                        case 2:
                            dx = ox;
                            dy = oy + 1;
                            break;
                        case 3:
                            dx = ox - 1;
                            dy = oy + 1;
                            break;
                        case 4:
                            dx = ox - 1;
                            dy = oy;
                            break;
                        case 5:
                            dx = ox - 1;
                            dy = oy - 1;
                            break;
                        case 6:
                            dx = ox;
                            dy = oy - 1;
                            break;
                        case 7:
                            dx = ox + 1;
                            dy = oy - 1;
                            break;

                    }


                } else {
                    dx = ((int) (49 * Math.random())) % 7;
                    dy = ((int) (49 * Math.random())) % 7;

                }

            } while (((dx < 0) || (dx > 7) || (dy < 0) || (dy > 7)));



            if (m.getPiece(ox, oy) != null) {
                if ((m.isValidMove(ox, oy, dx, dy))) {
                    randomOk = true;
                }
            }


        }

    }

    private ConjuntoXY[] acharMovimentosPossiveis(Match m) {
        ConjuntoXY[] movimentosPossiveis = new ConjuntoXY[100];
        int numeroDeMovimentos = 0;

        Piece peca;

        for (int i = 0; i <= 15; i++) {
            peca = escolhePeca(i, m);


            if (peca instanceof Pawn) {

                if (((ox + 1) <= 7) && ((oy + 1) <= 7)) {
                    if (m.getPiece(ox + 1, oy + 1) != null) {
                        if (!(m.getPiece(ox + 1, oy + 1).getColor().equals(peca.getColor()))) {

                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy + 1);
                            numeroDeMovimentos++;

                        }
                    }
                }

                if (((ox - 1) >= 0) && ((oy + 1) <= 7)) {
                    if (m.getPiece(ox - 1, oy + 1) != null) {
                        if (!(m.getPiece(ox - 1, oy + 1).getColor().equals(peca.getColor()))) {

                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy + 1);
                            numeroDeMovimentos++;
                        }
                    }
                }



            } else if (peca instanceof Rook) {

                for (int torrecount = 0; torrecount <= 7; torrecount++) {

                    if (!(m.getPiece(ox, torrecount) == null)) {
                        if (!(m.getPiece(ox, torrecount).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, torrecount);
                            numeroDeMovimentos++;
                        }
                    }

                    if (!(m.getPiece(torrecount, oy) == null)) {
                        if (!(m.getPiece(torrecount, oy).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, torrecount, oy);
                            numeroDeMovimentos++;
                        }
                    }

                }

            } else if (peca instanceof Bishop) {

                for (int bispocount = 0; bispocount <= 7; bispocount++) {

                    if ((ox + bispocount <= 7) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox + bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox - bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox - bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox + bispocount <= 7) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox + bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }


                }


            } else if (peca instanceof Knight) {
                for (int cavalocount = 0; cavalocount <= 7; cavalocount++) {
                    switch (cavalocount) {
                        case 0:
                            if ((ox + 1 <= 7) && (oy + 2 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy + 2) == null)) {
                                    if (!(m.getPiece(ox + 1, oy + 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy + 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }

                            break;
                        case 1:

                            if ((oy + 1 <= 7) && (ox + 2 <= 7)) {
                                if (!(m.getPiece(ox + 2, oy + 1) == null)) {
                                    if (!(m.getPiece(ox + 2, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 2, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 2:

                            if ((ox - 1 >= 0) && (oy - 2 >= 0)) {
                                if (!(m.getPiece(ox - 1, oy - 2) == null)) {
                                    if (!(m.getPiece(ox - 1, oy - 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy - 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 3:

                            if ((oy - 1 >= 0) && (ox - 2 >= 0)) {
                                if (!(m.getPiece(ox - 2, oy - 1) == null)) {
                                    if (!(m.getPiece(ox - 2, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 2, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 4:

                            if ((ox - 1 >= 0) && (oy + 2 <= 7)) {
                                if (!(m.getPiece(ox - 1, oy + 2) == null)) {
                                    if (!(m.getPiece(ox - 1, oy + 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy + 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 5:

                            if ((ox - 2 >= 0) && (oy + 1 <= 7)) {
                                if (!(m.getPiece(ox - 2, oy + 1) == null)) {
                                    if (!(m.getPiece(ox - 2, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 2, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 6:

                            if ((oy - 2 >= 0) && (ox + 1 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy - 2) == null)) {
                                    if (!(m.getPiece(ox + 1, oy - 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy - 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 7:

                            if ((oy - 1 >= 0) && (ox + 2 <= 7)) {
                                if (!(m.getPiece(ox + 2, oy - 1) == null)) {
                                    if (!(m.getPiece(ox + 2, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 2, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;

                    }

                }


            } else if (peca instanceof King) {

                for (int cavalocount = 0; cavalocount <= 7; cavalocount++) {
                    switch (cavalocount) {
                        case 0:
                            if ((ox <= 7) && (oy + 1 <= 7)) {
                                if (!(m.getPiece(ox, oy + 1) == null)) {
                                    if (!(m.getPiece(ox, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }

                            break;
                        case 1:

                            if ((oy + 1 <= 7) && (ox + 1 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy + 1) == null)) {
                                    if (!(m.getPiece(ox + 1, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 2:

                            if ((ox + 1 <= 7) && (oy >= 0)) {
                                if (!(m.getPiece(ox + 1, oy) == null)) {
                                    if (!(m.getPiece(ox + 1, oy).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 3:

                            if ((oy - 1 >= 0) && (ox + 1 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy - 1) == null)) {
                                    if (!(m.getPiece(ox + 1, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 4:

                            if ((oy - 1 >= 0) && (oy <= 7)) {
                                if (!(m.getPiece(ox, oy - 1) == null)) {
                                    if (!(m.getPiece(ox, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 5:

                            if ((ox - 1 >= 0) && (oy - 1 >= 0)) {
                                if (!(m.getPiece(ox - 1, oy - 1) == null)) {
                                    if (!(m.getPiece(ox - 1, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 6:

                            if ((oy >= 0) && (ox - 1 >= 0)) {
                                if (!(m.getPiece(ox - 1, oy) == null)) {
                                    if (!(m.getPiece(ox - 1, oy).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 7:

                            if ((ox - 1 >= 0) && (oy + 1 <= 7)) {
                                if (!(m.getPiece(ox - 1, oy + 1) == null)) {
                                    if (!(m.getPiece(ox - 1, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;

                    }
                }

            } else if (peca instanceof Queen) {

                for (int torrecount = 0; torrecount <= 7; torrecount++) {

                    if (!(m.getPiece(ox, torrecount) == null)) {
                        if (!(m.getPiece(ox, torrecount).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, torrecount);
                            numeroDeMovimentos++;
                        }
                    }

                    if (!(m.getPiece(torrecount, oy) == null)) {
                        if (!(m.getPiece(torrecount, oy).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, torrecount, oy);
                            numeroDeMovimentos++;
                        }
                    }

                }

                for (int bispocount = 0; bispocount <= 7; bispocount++) {

                    if ((ox + bispocount <= 7) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox + bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox - bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox - bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox + bispocount <= 7) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox + bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }


                }


            }


        }


        return movimentosPossiveis;

    }

    /*public int melhorJogada(Match m, int nivel, int valor) {

    int valorDaJogada = 0;

    if (nivel == 0)
    {
    if(m.getPlayer1().getXeque()) valorDaJogada = 40;
    if(m.getPlayer2().getXeque()) valorDaJogada = -80;

    for(int i = 0; i < 16; i++)
    {
    if(m.getPlayer1().getPiece()[i] != null)
    {
    if(m.getPlayer1().getPiece()[i] instanceof Pawn) valorDaJogada = valorDaJogada - 5;
    if(m.getPlayer1().getPiece()[i] instanceof Knight) valorDaJogada = valorDaJogada - 20;
    if(m.getPlayer1().getPiece()[i] instanceof Bishop) valorDaJogada = valorDaJogada - 25;
    if(m.getPlayer1().getPiece()[i] instanceof Rook) valorDaJogada = valorDaJogada - 35;
    if(m.getPlayer1().getPiece()[i] instanceof Queen) valorDaJogada = valorDaJogada - 55;
    if(m.getPlayer1().getPiece()[i] instanceof King) valorDaJogada = valorDaJogada - 0;

    }

    if(m.getPlayer2().getPiece()[i] != null)
    {
    if(m.getPlayer2().getPiece()[i] instanceof Pawn) valorDaJogada = valorDaJogada + 5;
    if(m.getPlayer2().getPiece()[i] instanceof Knight) valorDaJogada = valorDaJogada + 20;
    if(m.getPlayer2().getPiece()[i] instanceof Bishop) valorDaJogada = valorDaJogada + 25;
    if(m.getPlayer2().getPiece()[i] instanceof Rook) valorDaJogada = valorDaJogada + 35;
    if(m.getPlayer2().getPiece()[i] instanceof Queen) valorDaJogada = valorDaJogada + 55;
    if(m.getPlayer2().getPiece()[i] instanceof King) valorDaJogada = valorDaJogada + 0;

    }

    }

    }
    else
    {
    ConjuntoXY[] iteracao = acharMovimentosPossiveis(m);
    for (int i = 0; i < iteracao.length; i++)
    {
    int tox = iteracao[i].cox;
    int toy = iteracao[i].coy;
    int tdx = iteracao[i].cdx;
    int tdy = iteracao[i].cdy;

    m.move(tox, toy, tdx, tdy);

    //Se as jogadas levam em fim de jogo
    //Avaliar quem ficou em xeque
    if(m.getEndGame())
    {
    if(m.getPlayer1().getXeque()) return 1000;
    else return -1000;
    }
    else
    {
    nivel--;
    valorDaJogada = melhorJogada(m, nivel, valor);

    }

    }
    }

    if(valorDaJogada)

    }*/

    public void gulosoMove(Match m) {

        // boolean randomOk = false;

        ConjuntoXY[] movimentosPossiveis = new ConjuntoXY[100];
        int numeroDeMovimentos = 0;

        Piece peca;

        for (int i = 0; i <= 15; i++) {
            peca = escolhePeca(i, m);


            if (peca instanceof Pawn) {

                if (((ox + 1) <= 7) && ((oy + 1) <= 7)) {
                    if (m.getPiece(ox + 1, oy + 1) != null) {
                        if (!(m.getPiece(ox + 1, oy + 1).getColor().equals(peca.getColor()))) {

                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy + 1);
                            numeroDeMovimentos++;

                        }
                    }
                }

                if (((ox - 1) >= 0) && ((oy + 1) <= 7)) {
                    if (m.getPiece(ox - 1, oy + 1) != null) {
                        if (!(m.getPiece(ox - 1, oy + 1).getColor().equals(peca.getColor()))) {

                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy + 1);
                            numeroDeMovimentos++;
                        }
                    }
                }



            } else if (peca instanceof Rook) {

                for (int torrecount = 0; torrecount <= 7; torrecount++) {

                    if (!(m.getPiece(ox, torrecount) == null)) {
                        if (!(m.getPiece(ox, torrecount).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, torrecount);
                            numeroDeMovimentos++;
                        }
                    }

                    if (!(m.getPiece(torrecount, oy) == null)) {
                        if (!(m.getPiece(torrecount, oy).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, torrecount, oy);
                            numeroDeMovimentos++;
                        }
                    }

                }

            } else if (peca instanceof Bishop) {

                for (int bispocount = 0; bispocount <= 7; bispocount++) {

                    if ((ox + bispocount <= 7) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox + bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox - bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox - bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox + bispocount <= 7) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox + bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }


                }


            } else if (peca instanceof Knight) {
                for (int cavalocount = 0; cavalocount <= 7; cavalocount++) {
                    switch (cavalocount) {
                        case 0:
                            if ((ox + 1 <= 7) && (oy + 2 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy + 2) == null)) {
                                    if (!(m.getPiece(ox + 1, oy + 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy + 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }

                            break;
                        case 1:

                            if ((oy + 1 <= 7) && (ox + 2 <= 7)) {
                                if (!(m.getPiece(ox + 2, oy + 1) == null)) {
                                    if (!(m.getPiece(ox + 2, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 2, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 2:

                            if ((ox - 1 >= 0) && (oy - 2 >= 0)) {
                                if (!(m.getPiece(ox - 1, oy - 2) == null)) {
                                    if (!(m.getPiece(ox - 1, oy - 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy - 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 3:

                            if ((oy - 1 >= 0) && (ox - 2 >= 0)) {
                                if (!(m.getPiece(ox - 2, oy - 1) == null)) {
                                    if (!(m.getPiece(ox - 2, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 2, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 4:

                            if ((ox - 1 >= 0) && (oy + 2 <= 7)) {
                                if (!(m.getPiece(ox - 1, oy + 2) == null)) {
                                    if (!(m.getPiece(ox - 1, oy + 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy + 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 5:

                            if ((ox - 2 >= 0) && (oy + 1 <= 7)) {
                                if (!(m.getPiece(ox - 2, oy + 1) == null)) {
                                    if (!(m.getPiece(ox - 2, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 2, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 6:

                            if ((oy - 2 >= 0) && (ox + 1 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy - 2) == null)) {
                                    if (!(m.getPiece(ox + 1, oy - 2).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy - 2);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 7:

                            if ((oy - 1 >= 0) && (ox + 2 <= 7)) {
                                if (!(m.getPiece(ox + 2, oy - 1) == null)) {
                                    if (!(m.getPiece(ox + 2, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 2, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;

                    }

                }


            } else if (peca instanceof King) {

                for (int cavalocount = 0; cavalocount <= 7; cavalocount++) {
                    switch (cavalocount) {
                        case 0:
                            if ((ox <= 7) && (oy + 1 <= 7)) {
                                if (!(m.getPiece(ox, oy + 1) == null)) {
                                    if (!(m.getPiece(ox, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }

                            break;
                        case 1:

                            if ((oy + 1 <= 7) && (ox + 1 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy + 1) == null)) {
                                    if (!(m.getPiece(ox + 1, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 2:

                            if ((ox + 1 <= 7) && (oy >= 0)) {
                                if (!(m.getPiece(ox + 1, oy) == null)) {
                                    if (!(m.getPiece(ox + 1, oy).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 3:

                            if ((oy - 1 >= 0) && (ox + 1 <= 7)) {
                                if (!(m.getPiece(ox + 1, oy - 1) == null)) {
                                    if (!(m.getPiece(ox + 1, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + 1, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 4:

                            if ((oy - 1 >= 0) && (oy <= 7)) {
                                if (!(m.getPiece(ox, oy - 1) == null)) {
                                    if (!(m.getPiece(ox, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 5:

                            if ((ox - 1 >= 0) && (oy - 1 >= 0)) {
                                if (!(m.getPiece(ox - 1, oy - 1) == null)) {
                                    if (!(m.getPiece(ox - 1, oy - 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy - 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }
                            break;
                        case 6:

                            if ((oy >= 0) && (ox - 1 >= 0)) {
                                if (!(m.getPiece(ox - 1, oy) == null)) {
                                    if (!(m.getPiece(ox - 1, oy).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;
                        case 7:

                            if ((ox - 1 >= 0) && (oy + 1 <= 7)) {
                                if (!(m.getPiece(ox - 1, oy + 1) == null)) {
                                    if (!(m.getPiece(ox - 1, oy + 1).getColor().equals(peca.getColor()))) {
                                        movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                        movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - 1, oy + 1);
                                        numeroDeMovimentos++;
                                    }
                                }
                            }


                            break;

                    }
                }

            } else if (peca instanceof Queen) {

                for (int torrecount = 0; torrecount <= 7; torrecount++) {

                    if (!(m.getPiece(ox, torrecount) == null)) {
                        if (!(m.getPiece(ox, torrecount).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox, torrecount);
                            numeroDeMovimentos++;
                        }
                    }

                    if (!(m.getPiece(torrecount, oy) == null)) {
                        if (!(m.getPiece(torrecount, oy).getColor().equals(peca.getColor()))) {
                            movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                            movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, torrecount, oy);
                            numeroDeMovimentos++;
                        }
                    }

                }

                for (int bispocount = 0; bispocount <= 7; bispocount++) {

                    if ((ox + bispocount <= 7) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox + bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy + bispocount <= 7)) {
                        if (!(m.getPiece(ox - bispocount, oy + bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy + bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy + bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox - bispocount >= 0) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox - bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox - bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox - bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }

                    if ((ox + bispocount <= 7) && (oy - bispocount >= 0)) {
                        if (!(m.getPiece(ox + bispocount, oy - bispocount) == null)) {
                            if (!(m.getPiece(ox + bispocount, oy - bispocount).getColor().equals(peca.getColor()))) {
                                movimentosPossiveis[numeroDeMovimentos] = new ConjuntoXY();
                                movimentosPossiveis[numeroDeMovimentos].adicionarConjunto(ox, oy, ox + bispocount, oy - bispocount);
                                numeroDeMovimentos++;

                            }
                        }

                    }


                }


            }


        }

        for (int i = 0; i < numeroDeMovimentos; i++) {

            if (!((movimentosPossiveis[i].getDx() > 7) || (movimentosPossiveis[i].getDy() > 7) || (movimentosPossiveis[i].getDx() < 0) || (movimentosPossiveis[i].getDy() < 0))) {

                if ((m.getPiece(movimentosPossiveis[i].getDx(), movimentosPossiveis[i].getDy())) instanceof Pawn) {
                    movimentosPossiveis[i].setValor(1);
                }
                if ((m.getPiece(movimentosPossiveis[i].getDx(), movimentosPossiveis[i].getDy())) instanceof Knight) {
                    movimentosPossiveis[i].setValor(3);
                }
                if ((m.getPiece(movimentosPossiveis[i].getDx(), movimentosPossiveis[i].getDy())) instanceof Bishop) {
                    movimentosPossiveis[i].setValor(4);
                }
                if ((m.getPiece(movimentosPossiveis[i].getDx(), movimentosPossiveis[i].getDy())) instanceof Rook) {
                    movimentosPossiveis[i].setValor(6);
                }
                if ((m.getPiece(movimentosPossiveis[i].getDx(), movimentosPossiveis[i].getDy())) instanceof Queen) {
                    movimentosPossiveis[i].setValor(10);
                }

            }

        }

        ConjuntoXY melhorMov = movimentosPossiveis[0];


        //BubbleSort
        boolean houveTroca = true;
        ConjuntoXY aux;
        while (houveTroca) {
            houveTroca = false;
            for (int i = 0; i < numeroDeMovimentos - 1; i++) {
                if (movimentosPossiveis[i].getValor() < movimentosPossiveis[i + 1].getValor()) {
                    houveTroca = true;
                    aux = movimentosPossiveis[i];
                    movimentosPossiveis[i] = movimentosPossiveis[i + 1];
                    movimentosPossiveis[i + 1] = aux;
                }
            }
        }

        if ((!m.getPlayer2().getXeque()) || (!m.getMovimentoDesfeito())) {
            boolean testeMov = false;
            int contador = 0;


            while (!testeMov) {

                while (contador <= numeroDeMovimentos) {
                    melhorMov = movimentosPossiveis[contador];

                    if (melhorMov != null) {
                        ox = melhorMov.getOx();
                        oy = melhorMov.getOy();
                        dx = melhorMov.getDx();
                        dy = melhorMov.getDy();

                        if (m.getPiece(ox, oy) != null) {
                            if ((m.isValidMove(ox, oy, dx, dy))) {
                                testeMov = true;
                                break;
                            }
                        }

                    }
                    contador++;
                }
                if (!testeMov) {
                    randomMove(m);
                    testeMov = true;
                }


            }

        } else {

            if (m.getPlayer2().getXeque())
            {
            randomMove(m);
            while (m.getPlayer2().getXeque())
            {
                m.undoMove(3);
                randomMove(m);
            }
            }
            else
                randomMove(m);

        }

    }

    public void sicilianDefenseOpening(Match m) {

        /*if( (m.getNumberOfTurns() == 1) && (m.getPiece(4, 4)!=null) ){
        ox = 2;
        oy = 1;
        dx = 2;
        dy = 3;
        }*/

        if (sicilianDefense) {

            switch (m.getNumberOfTurns()) {

                case 1:
                    if ((this.memoria[0].getOx()) == 4 && (this.memoria[0].getOy()) == 6 && (this.memoria[0].getDx()) == 4 && (this.memoria[0].getDy()) == 4) {
                        ox = 2;
                        oy = 1;
                        dx = 2;
                        dy = 3;
                    } else {
                        sicilianDefense = false;
                        gulosoMove(m);
                    }
                    break;
                case 3:

                    if ((this.memoria[0].getOx()) == 3 && (this.memoria[0].getOy()) == 6 && (this.memoria[0].getDx()) == 3 && (this.memoria[0].getDy()) == 4) {
                        ox = 2;
                        oy = 3;
                        dx = 3;
                        dy = 4;
                    } else {
                        sicilianDefense = false;
                        gulosoMove(m);
                    }

                    break;
                case 5:

                    if ((this.memoria[0].getOx()) == 6 && (this.memoria[0].getOy()) == 7 && (this.memoria[0].getDx()) == 5 && (this.memoria[0].getDy()) == 5) {
                        ox = 3;
                        oy = 1;
                        dx = 3;
                        dy = 2;
                    } else {
                        sicilianDefense = false;
                        gulosoMove(m);
                    }
                    break;

                case 7:

                    if ((this.memoria[0].getOx()) == 3 && (this.memoria[0].getOy()) == 6 && (this.memoria[0].getDx()) == 3 && (this.memoria[0].getDy()) == 4) {
                        ox = 2;
                        oy = 3;
                        dx = 3;
                        dy = 4;
                    } else {
                        sicilianDefense = false;
                        gulosoMove(m);
                    }
                    break;

                case 9:

                    if ((this.memoria[0].getOx()) == 5 && (this.memoria[0].getOy()) == 5 && (this.memoria[0].getDx()) == 3 && (this.memoria[0].getDy()) == 4) {
                        ox = 6;
                        oy = 0;
                        dx = 5;
                        dy = 2;
                    } else {
                        sicilianDefense = false;
                        gulosoMove(m);
                    }
                    break;

                case 11:

                    if ((this.memoria[0].getOx()) == 1 && (this.memoria[0].getOy()) == 7 && (this.memoria[0].getDx()) == 2 && (this.memoria[0].getDy()) == 5) {
                        ox = 1;
                        oy = 0;
                        dx = 2;
                        dy = 2;
                    } else {
                        sicilianDefense = false;
                        gulosoMove(m);
                    }
                    break;


                default:
                    sicilianDefense = false;
                    gulosoMove(m);
                    break;


            }

        } else {
            gulosoMove(m);
        }



    }

    public void noobMove(Match m) {
    }
}
